package com.example.message.service.impl;

import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.message.entity.MessageTemplate;
import com.example.message.mapper.MessageTemplateMapper;
import com.example.message.service.MessageTemplateService;
import com.example.project.utils.StringUtils;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * 通知模板服务实现
 */
@Service
public class MessageTemplateServiceImpl extends ServiceImpl<MessageTemplateMapper, MessageTemplate>
		implements MessageTemplateService {

	private ObjectMapper objectMapper = new ObjectMapper();

	private static final Pattern VARIABLE_PATTERN = Pattern.compile("\\{([^}]+)\\}");

	/**
	 * 根据模板代码获取模板
	 * @param templateCode 模板代码
	 * @return 模板对象
	 */
	@Override
	public MessageTemplate getByCode(String templateCode) {
		QueryWrapper<MessageTemplate> queryWrapper = new QueryWrapper<>();
		queryWrapper.eq("template_code", templateCode);
		queryWrapper.eq("status", 1); // 只查询启用的模板
		queryWrapper.eq("del_flag", 0);
		return getOne(queryWrapper);
	}

	/**
	 * 渲染模板（使用Map参数）
	 * @param templateCode 模板代码
	 * @param params 模板参数Map
	 * @return 渲染后的模板内容
	 */
	@Override
	public String renderTemplate(String templateCode, Map<String, Object> params) {
		MessageTemplate template = getByCode(templateCode);
		if (template == null) {
			throw new RuntimeException("模板不存在或已禁用: " + templateCode);
		}

		String content = template.getContent();
		if (params != null && !params.isEmpty()) {
			content = replaceVariables(content, params);
		}

		return content;
	}

	/**
	 * 替换模板中的变量
	 * @param content 模板内容
	 * @param params 参数Map
	 * @return 替换后的内容
	 */
	private String replaceVariables(String content, Map<String, Object> params) {
		StringBuffer result = new StringBuffer();
		Matcher matcher = VARIABLE_PATTERN.matcher(content);

		while (matcher.find()) {
			String variableName = matcher.group(1);
			Object value = params.get(variableName);
			String replacement = value != null ? value.toString() : "";
			matcher.appendReplacement(result, Matcher.quoteReplacement(replacement));
		}

		matcher.appendTail(result);
		return result.toString();
	}

	/**
	 * 查询模板列表
	 * @param messageTemplate 查询条件
	 * @return 模板列表
	 */
	@Override
	public List<MessageTemplate> selectNoticeTemplateList(MessageTemplate messageTemplate) {
		QueryWrapper<MessageTemplate> wrapper = new QueryWrapper<>();
		if (StringUtils.isNotEmpty(messageTemplate.getTemplateName())) {
			wrapper.like("template_name", messageTemplate.getTemplateName());
		}
		if (StringUtils.isNotEmpty(messageTemplate.getTemplateCode())) {
			wrapper.eq("template_code", messageTemplate.getTemplateCode());
		}
		if (messageTemplate.getTemplateType() != null) {
			wrapper.eq("template_type", messageTemplate.getTemplateType());
		}
		if (messageTemplate.getStatus() != null) {
			wrapper.eq("status", messageTemplate.getStatus());
		}
		wrapper.orderByDesc("create_time");
		return baseMapper.selectList(wrapper);
	}

	/**
	 * 根据ID查询模板详情
	 * @param templateId 模板ID
	 * @return 模板详情
	 */
	@Override
	public MessageTemplate selectNoticeTemplateById(Long templateId) {
		return baseMapper.selectById(templateId);
	}

	/**
	 * 根据模板代码查询模板
	 * @param templateCode 模板代码
	 * @return 模板对象
	 */
	@Override
	public MessageTemplate selectNoticeTemplateByCode(String templateCode) {
		QueryWrapper<MessageTemplate> wrapper = new QueryWrapper<>();
		wrapper.eq("template_code", templateCode);
		wrapper.eq("status", 1); // 只查询启用的模板
		return baseMapper.selectOne(wrapper);
	}

	/**
	 * 新增模板
	 * @param messageTemplate 模板对象
	 * @return 插入结果（影响行数）
	 */
	@Override
	public int insertNoticeTemplate(MessageTemplate messageTemplate) {
		return baseMapper.insert(messageTemplate);
	}

	/**
	 * 更新模板
	 * @param messageTemplate 模板对象
	 * @return 更新结果（影响行数）
	 */
	@Override
	public int updateNoticeTemplate(MessageTemplate messageTemplate) {
		return baseMapper.updateById(messageTemplate);
	}

	/**
	 * 批量删除模板
	 * @param templateIds 模板ID数组
	 * @return 删除的模板数量
	 */
	@Override
	public int deleteNoticeTemplateByIds(Long[] templateIds) {
		for (Long templateId : templateIds) {
			baseMapper.deleteById(templateId);
		}
		return templateIds.length;
	}

	/**
	 * 渲染模板（使用JSON字符串参数）
	 * @param templateCode 模板代码
	 * @param variables 变量JSON字符串
	 * @return 渲染后的模板内容
	 */
	@Override
	public String renderTemplate(String templateCode, String variables) {
		MessageTemplate template = selectNoticeTemplateByCode(templateCode);
		if (template == null) {
			throw new RuntimeException("模板不存在或已禁用");
		}

		String content = template.getContent();
		if (StringUtils.isEmpty(variables)) {
			return content;
		}

		try {
			// 解析变量JSON
			Map<String, Object> varMap = objectMapper.readValue(variables, new TypeReference<Map<String, Object>>() {
			});
			// 替换模板变量
			Pattern pattern = Pattern.compile("\\{([^}]+)\\}");
			Matcher matcher = pattern.matcher(content);
			StringBuffer result = new StringBuffer();

			while (matcher.find()) {
				String key = matcher.group(1);
				String value = varMap.containsKey(key) ? String.valueOf(varMap.get(key)) : "";
				matcher.appendReplacement(result, Matcher.quoteReplacement(value));
			}
			matcher.appendTail(result);

			return result.toString();
		} catch (Exception e) {
			throw new RuntimeException("模板变量渲染失败: " + e.getMessage());
		}
	}
}